devisualization.util.opengl.function_wrappers.deprecated

1 /*
2  * The MIT License (MIT)
3  *
4  * Copyright (c) 2014 Devisualization (Richard Andrew Cattermole)
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 module devisualization.util.opengl.function_wrappers.deprecated_.v10v11;
25 import gl = derelict.opengl3.gl;
26 public import derelict.opengl3.gl : glEnd, glListBase, glCallList, glEndList, glGenLists, glDeleteLists, glIsList, glLineStipple;
27 
28 enum ListMode {
29     Compile = gl.GL_COMPILE,
30     CompileAndExecute = gl.GL_COMPILE_AND_EXECUTE
31 }
32 
33 enum CallListSizes {
34     UnsignedByte = gl.GL_UNSIGNED_BYTE,
35     Byte = gl.GL_BYTE,
36     UnsignedShort = gl.GL_UNSIGNED_SHORT,
37     Short = gl.GL_SHORT,
38     UnsignedInt = gl.GL_UNSIGNED_INT,
39     Int = gl.GL_INT,
40     Float = gl.GL_FLOAT,
41     Bytes2 = gl.GL_2_BYTES,
42     Bytes3 = gl.GL_3_BYTES,
43     Bytes4 = gl.GL_4_BYTES
44 }
45 
46 enum BeginPrimitives {
47     Points = gl.GL_POINTS,
48     LineStrip = gl.GL_LINE_STRIP,
49     LineLoop = gl.GL_LINE_LOOP,
50     Lines = gl.GL_LINES,
51     TriangleStrip = gl.GL_TRIANGLE_STRIP,
52     TriangleFan = gl.GL_TRIANGLE_FAN,
53     Triangles = gl.GL_TRIANGLES,
54     Quads = gl.GL_QUADS,
55     QuadStrip = gl.GL_QUAD_STRIP,
56     Polygon = gl.GL_POLYGON,
57 }
58 
59 enum LightSource {
60     SpotExponent = gl.GL_SPOT_EXPONENT,
61     SpotCutOff = gl.GL_SPOT_CUTOFF,
62     ConstantAttenuation = gl.GL_CONSTANT_ATTENUATION,
63     LinearAttenuation = gl.GL_LINEAR_ATTENUATION,
64     QuadraticAttenuation  = gl.GL_QUADRATIC_ATTENUATION
65 }
66 
67 enum MaterialType {
68     Ambient = gl.GL_AMBIENT,
69     Diffuse = gl.GL_DIFFUSE,
70     Specular = gl.GL_SPECULAR,
71     Emission = gl.GL_EMISSION
72 }
73 
74 enum ShadeModel {
75     Flat = gl.GL_FLAT,
76     Smooth = gl.GL_SMOOTH
77 }
78 
79 enum MaterialFace {
80     Front = gl.GL_FRONT,
81     Back = gl.GL_BACK,
82     FrontAndBack = gl.GL_FRONT_AND_BACK
83 }
84 
85 enum FogType {
86     FogMode = gl.GL_FOG_MODE,
87     FogDensity = gl.GL_FOG_DENSITY,
88     FogStart = gl.GL_FOG_START,
89     FogEnd = gl.GL_FOG_END,
90     FogIndex = gl.GL_FOG_INDEX,
91     FogCoordSource = gl.GL_FOG_COORD_SRC
92 }
93 
94 enum TextureCoordinate {
95     S = gl.GL_S,
96     T = gl.GL_T,
97     R = gl.GL_R,
98     Q = gl.GL_Q
99 }
100 
101 void glNewList(uint list, ListMode mode) {
102     gl.glNewList(list, mode);
103 }
104 
105 void glCallLists(T)(CallListSizes type, T[] lists) {
106     gl.glCallLists(lists.length, type, lists.ptr);
107 }
108 
109 void glBegin(BeginPrimitives mode) {
110     gl.glBegin(mode);
111 }
112 
113 void glVertex(short a, short b)
114     { gl.glVertex2s(a, b); }
115 void glVertex(int a, int b)
116     { gl.glVertex2i(a, b); }
117 void glVertex(float a, float b)
118     { gl.glVertex2f(a, b); }
119 void glVertex(double a, double b)
120     { gl.glVertex2d(a, b); }
121 
122 void glVertex(short a, short b, short c)
123     { gl.glVertex3s(a, b, c); }
124 void glVertex(int a, int b, int c)
125     { gl.glVertex3i(a, b, c); }
126 void glVertex(float a, float b, float c)
127     { gl.glVertex3f(a, b, c); }
128 void glVertex(double a, double b, double c)
129     { gl.glVertex3d(a, b, c); }
130 
131 void glVertex(short a, short b, short c, short d)
132     { gl.glVertex4s(a, b, c, d); }
133 void glVertex(int a, int b, int c, int d)
134     { gl.glVertex4i(a, b, c, d); }
135 void glVertex(float a, float b, float c, float d)
136     { gl.glVertex4f(a, b, c, d); }
137 void glVertex(double a, double b, double c, double d)
138     { gl.glVertex4d(a, b, c, d); }
139 
140 void glVertex(short[] value)
141 in {
142     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
143 } body {
144     if (value.length == 2)
145         gl.glVertex2sv(value.ptr);
146     else if (value.length == 3)
147         gl.glVertex3sv(value.ptr);
148     else if (value.length == 4)
149         gl.glVertex4sv(value.ptr);
150 }
151 
152 void glVertex(int[] value)
153 in {
154     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
155 } body {
156     if (value.length == 2)
157         gl.glVertex2iv(value.ptr);
158     else if (value.length == 3)
159         gl.glVertex3iv(value.ptr);
160     else if (value.length == 4)
161         gl.glVertex4iv(value.ptr);
162 }
163 
164 void glVertex(float[] value)
165 in {
166     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
167 } body {
168     if (value.length == 2)
169         gl.glVertex2fv(value.ptr);
170     else if (value.length == 3)
171         gl.glVertex3fv(value.ptr);
172     else if (value.length == 4)
173         gl.glVertex4fv(value.ptr);
174 }
175 
176 void glVertex(double[] value)
177 in {
178     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
179 } body {
180     if (value.length == 2)
181         gl.glVertex2dv(value.ptr);
182     else if (value.length == 3)
183         gl.glVertex3dv(value.ptr);
184     else if (value.length == 4)
185         gl.glVertex4dv(value.ptr);
186 }
187 
188 void glNormal(byte a, byte b, byte c)
189     { gl.glNormal3b(a, b, c); }
190 void glNormal(double a, double b, double c)
191     { gl.glNormal3d(a, b, c); }
192 void glNormal(float a, float b, float c)
193     { gl.glNormal3f(a, b, c); }
194 void glNormal(int a, int b, int c)
195     { gl.glNormal3i(a, b, c); }
196 void glNormal(short a, short b, short c)
197     { gl.glNormal3s(a, b, c); }
198 
199 void glNormal(byte[] value)
200     in { assert(value.length == 3); }
201     body { gl.glNormal3bv(cast(const)value.ptr); }
202 void glNormal(double[] value)
203     in { assert(value.length == 3); }
204     body { gl.glNormal3dv(value.ptr); }
205 void glNormal(float[] value)
206     in { assert(value.length == 3); }
207     body { gl.glNormal3fv(value.ptr); }
208 void glNormal(int[] value)
209     in { assert(value.length == 3); }
210     body { gl.glNormal3iv(value.ptr); }
211 void glNormal(short[] value)
212     in { assert(value.length == 3); }
213     body { gl.glNormal3sv(value.ptr); }
214 
215 void glIndex(double value) { gl.glIndexd(value); }
216 void glIndex(float value) { gl.glIndexf(value); }
217 void glIndex(int value) { gl.glIndexi(value); }
218 void glIndex(short value) { gl.glIndexs(value); }
219 void glIndex(ubyte value) { gl.glIndexub(value); }
220 
221 /*
222 alias da_glIndexdv = void function( const( GLdouble )* );
223 alias da_glIndexfv = void function( const( GLfloat )* );
224 alias da_glIndexiv = void function( const( GLint )* );
225 alias da_glIndexsv = void function( const( GLshort )* );
226 alias da_glIndexubv = void function( const( GLubyte )* );*/
227 
228 void glColor(byte a, byte b, byte c) { gl.glColor3b(a, b, c); }
229 void glColor(double a, double b, double c) { gl.glColor3d(a, b, c); }
230 void glColor(float a, float b, float c) { gl.glColor3f(a, b, c); }
231 void glColor(int a, int b, int c) { gl.glColor3i(a, b, c); }
232 void glColor(short a, short b, short c) { gl.glColor3s(a, b, c); }
233 
234 void glColor(ubyte a, ubyte b, ubyte c) { gl.glColor3ub(a, b, c); }
235 void glColor(uint a, uint b, uint c) { gl.glColor3ui(a, b, c); }
236 void glColor(ushort a, ushort b, ushort c) { gl.glColor3us(a, b, c); }
237 
238 void glColor(byte a, byte b, byte c, byte d) { gl.glColor4b(a, b, c, d); }
239 void glColor(double a, double b, double c, double d) { gl.glColor4d(a, b, c, d); }
240 void glColor(float a, float b, float c, float d) { gl.glColor4f(a, b, c, d); }
241 void glColor(int a, int b, int c, int d) { gl.glColor4i(a, b, c, d); }
242 void glColor(short a, short b, short c, short d) { gl.glColor4s(a, b, c, d); }
243 
244 void glColor(ubyte a, ubyte b, ubyte c, byte d) { gl.glColor4ub(a, b, c, d); }
245 void glColor(uint a, uint b, uint c, uint d) { gl.glColor4ui(a, b, c, d); }
246 void glColor(ushort a, ushort b, ushort c, ushort d) { gl.glColor4us(a, b, c, d); }
247 
248 void glColor(byte[] value)
249 in {
250     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
251 } body {
252     if (value.length == 3)
253         gl.glColor3bv(value.ptr);
254     else if (value.length == 4)
255         gl.glColor4bv(value.ptr);
256 }
257 
258 void glColor(double[] value)
259 in {
260     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
261 } body {
262     if (value.length == 3)
263         gl.glColor3dv(value.ptr);
264     else if (value.length == 4)
265         gl.glColor4dv(value.ptr);
266 }
267 
268 void glColor(float[] value)
269 in {
270     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
271 } body {
272     if (value.length == 3)
273         gl.glColor3fv(value.ptr);
274     else if (value.length == 4)
275         gl.glColor4fv(value.ptr);
276 }
277 
278 void glColor(int[] value)
279 in {
280     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
281 } body {
282     if (value.length == 3)
283         gl.glColor3iv(value.ptr);
284     else if (value.length == 4)
285         gl.glColor4iv(value.ptr);
286 }
287 
288 void glColor(short[] value)
289 in {
290     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
291 } body {
292     if (value.length == 3)
293         gl.glColor3sv(value.ptr);
294     else if (value.length == 4)
295         gl.glColor4sv(value.ptr);
296 }
297 
298 void glColor(ubyte[] value)
299 in {
300     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
301 } body {
302     if (value.length == 3)
303         gl.glColor3ubv(value.ptr);
304     else if (value.length == 4)
305         gl.glColor4ubv(value.ptr);
306 }
307 
308 void glColor(uint[] value)
309 in {
310     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
311 } body {
312     if (value.length == 3)
313         gl.glColor3uiv(value.ptr);
314     else if (value.length == 4)
315         gl.glColor4uiv(value.ptr);
316 }
317 
318 void glColor(ushort[] value)
319 in {
320     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
321 } body {
322     if (value.length == 3)
323         gl.glColor3usv(value.ptr);
324     else if (value.length == 4)
325         gl.glColor4usv(value.ptr);
326 }
327 
328 void glTexCoord(double a) { gl.glTexCoord1d(a); }
329 void glTexCoord(float a) { gl.glTexCoord1f(a); }
330 void glTexCoord(int a) { gl.glTexCoord1i(a); }
331 void glTexCoord(short a) { gl.glTexCoord1s(a); }
332 
333 void glTexCoord(double a, double b) { gl.glTexCoord2d(a, b); }
334 void glTexCoord(float a, float b) { gl.glTexCoord2f(a, b); }
335 void glTexCoord(int a, int b) { gl.glTexCoord2i(a, b); }
336 void glTexCoord(short a, short b) { gl.glTexCoord2s(a, b); }
337 
338 void glTexCoord(double a, double b, double c) { gl.glTexCoord3d(a, b, c); }
339 void glTexCoord(float a, float b, float c) { gl.glTexCoord3f(a, b, c); }
340 void glTexCoord(int a, int b, int c) { gl.glTexCoord3i(a, b, c); }
341 void glTexCoord(short a, short b, short c) { gl.glTexCoord3s(a, b, c); }
342 
343 void glTexCoord(double a, double b, double c, double d) { gl.glTexCoord4d(a, b, c, d); }
344 void glTexCoord(float a, float b, float c, float d) { gl.glTexCoord4f(a, b, c, d); }
345 void glTexCoord(int a, int b, int c, int d) { gl.glTexCoord4i(a, b, c, d); }
346 void glTexCoord(short a, short b, short c, short d) { gl.glTexCoord4s(a, b, c, d); }
347 
348 void glTexCoord(double[] value)
349 in {
350     assert(value.length >= 1 && value.length <= 4, "Invalid array length");
351 } body {
352     if (value.length == 1)
353         gl.glTexCoord1dv(value.ptr);
354     else if (value.length == 2)
355         gl.glTexCoord2dv(value.ptr);
356     else if (value.length == 3)
357         gl.glTexCoord3dv(value.ptr);
358     else if (value.length == 4)
359         gl.glTexCoord4dv(value.ptr);
360 }
361 
362 void glTexCoord(float[] value)
363 in {
364     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
365 } body {
366     if (value.length == 1)
367         gl.glTexCoord1fv(value.ptr);
368     else if (value.length == 2)
369         gl.glTexCoord2fv(value.ptr);
370     else if (value.length == 3)
371         gl.glTexCoord3fv(value.ptr);
372     else if (value.length == 4)
373         gl.glTexCoord4fv(value.ptr);
374 }
375 
376 void glTexCoord(int[] value)
377 in {
378     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
379 } body {
380     if (value.length == 1)
381         gl.glTexCoord1iv(value.ptr);
382     else if (value.length == 2)
383         gl.glTexCoord2iv(value.ptr);
384     else if (value.length == 3)
385         gl.glTexCoord3iv(value.ptr);
386     else if (value.length == 4)
387         gl.glTexCoord4iv(value.ptr);
388 }
389 
390 void glTexCoord(short[] value)
391 in {
392     assert(value.length >= 3 && value.length <= 4, "Invalid array length");
393 } body {
394     if (value.length == 1)
395         gl.glTexCoord1sv(value.ptr);
396     else if (value.length == 2)
397         gl.glTexCoord2sv(value.ptr);
398     else if (value.length == 3)
399         gl.glTexCoord3sv(value.ptr);
400     else if (value.length == 4)
401         gl.glTexCoord4sv(value.ptr);
402 }
403 
404 void glRasterPos(double a, double b) { gl.glRasterPos2d(a, b); }
405 void glRasterPos(float a, float b) { gl.glRasterPos2f(a, b); }
406 void glRasterPos(int a, int b) { gl.glRasterPos2i(a, b); }
407 void glRasterPos(short a, short b) { gl.glRasterPos2s(a, b); }
408 
409 void glRasterPos(double a, double b, double c) { gl.glRasterPos3d(a, b, c); }
410 void glRasterPos(float a, float b, float c) { gl.glRasterPos3f(a, b, c); }
411 void glRasterPos(int a, int b, int c) { gl.glRasterPos3i(a, b, c); }
412 void glRasterPos(short a, short b, short c) { gl.glRasterPos3s(a, b, c); }
413 
414 void glRasterPos(double a, double b, double c, double d) { gl.glRasterPos4d(a, b, c, d); }
415 void glRasterPos(float a, float b, float c, float d) { gl.glRasterPos4f(a, b, c, d); }
416 void glRasterPos(int a, int b, int c, int d) { gl.glRasterPos4i(a, b, c, d); }
417 void glRasterPos(short a, short b, short c, short d) { gl.glRasterPos4s(a, b, c, d); }
418 
419 void glRasterPos(double[] value)
420 in {
421     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
422 } body {
423     if (value.length == 2)
424         gl.glRasterPos2dv(value.ptr);
425     else if (value.length == 3)
426         gl.glRasterPos3dv(value.ptr);
427     else if (value.length == 4)
428         gl.glRasterPos4dv(value.ptr);
429 }
430 
431 void glRasterPos(float[] value)
432 in {
433     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
434 } body {
435     if (value.length == 2)
436         gl.glRasterPos2fv(value.ptr);
437     else if (value.length == 3)
438         gl.glRasterPos3fv(value.ptr);
439     else if (value.length == 4)
440         gl.glRasterPos4fv(value.ptr);
441 }
442 
443 void glRasterPos(int[] value)
444 in {
445     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
446 } body {
447     if (value.length == 2)
448         gl.glRasterPos2iv(value.ptr);
449     else if (value.length == 3)
450         gl.glRasterPos3iv(value.ptr);
451     else if (value.length == 4)
452         gl.glRasterPos4iv(value.ptr);
453 }
454 
455 void glRasterPos(short[] value)
456 in {
457     assert(value.length >= 2 && value.length <= 4, "Invalid array length");
458 } body {
459     if (value.length == 2)
460         gl.glRasterPos2sv(value.ptr);
461     else if (value.length == 3)
462         gl.glRasterPos3sv(value.ptr);
463     else if (value.length == 4)
464         gl.glRasterPos4sv(value.ptr);
465 }
466 
467 void glRect(double a, double b, double c, double d) { gl.glRectd(a, b, c, d); }
468 void glRect(float a, float b, float c, float d) { gl.glRectf(a, b, c, d); }
469 void glRect(int a, int b, int c, int d) { gl.glRecti(a, b, c, d); }
470 void glRect(short a, short b, short c, short d) { gl.glRects(a, b, c, d); }
471 
472 /*
473 alias da_glRectdv = void function( const( GLdouble )*, const( GLdouble )* );
474 alias da_glRectfv = void function( const( GLfloat )*, const( GLfloat )* );
475 alias da_glRectiv = void function( const( GLint )*, const( GLint )* );
476 alias da_glRectsv = void function( const( GLshort )*, const( GLshort )* );*/
477 
478 void glClipPlane(uint i, double[] plane)
479     in { assert(plane.length == 4); }
480     body { gl.glClipPlane(i, plane.ptr); }
481 
482 double[4] glGetClipPlane(uint i) {
483     double[4] ret;
484     gl.glGetClipPlane(i, ret.ptr);
485     return ret;
486 }
487 
488 void glShadeModel(ShadeModel mode) { gl.glShadeModel(mode); }
489 
490 void glLight(uint light, LightSource name, float param) { gl.glLightf(light, name, param); }
491 void glLight(uint light, LightSource name, int param) { gl.glLightf(light, name, param); }
492 
493 /*
494 alias da_glLightfv = void function( GLenum,GLenum,const( GLfloat )* );
495 alias da_glLightiv = void function( GLenum,GLenum,const( GLint )* );
496 alias da_glGetLightfv = void function( GLenum,GLenum,GLfloat* );
497 alias da_glGetLightiv = void function( GLenum,GLenum,GLint* );*/
498 
499 void glLightModelf(float param) { gl.glLightModelf(gl.GL_LIGHT_MODEL_TWO_SIDE, param); }
500 void glLightModeli(int param) { gl.glLightModeli(gl.GL_LIGHT_MODEL_TWO_SIDE, param); }
501 
502 /*
503 alias da_glLightModelfv = void function( GLenum,const( GLfloat )* );
504 alias da_glLightModeliv = void function( GLenum,const( GLint )* );*/
505 
506 void glMaterial(float param) { gl.glMaterialf(gl.GL_FRONT_AND_BACK, gl.GL_SHININESS, param); }
507 void glMaterial(int param) { gl.glMateriali(gl.GL_FRONT_AND_BACK, gl.GL_SHININESS, param); }
508 
509 /*
510 alias da_glMaterialfv = void function( GLenum,GLenum,const( GLfloat )* );
511 alias da_glMaterialiv = void function( GLenum,GLenum,const( GLint )* );*/
512 
513 void glGetMaterial(bool frontFace, MaterialType name, out float param) { gl.glGetMaterialfv(frontFace ? gl.GL_FRONT : gl.GL_BACK, name, &param); }
514 void glGetMaterial(bool frontFace, MaterialType name, out int param) { gl.glGetMaterialiv(frontFace ? gl.GL_FRONT : gl.GL_BACK, name, &param); }
515 void glColorMaterial(MaterialFace face, MaterialType type) { gl.glColorMaterial(face, type); }
516 
517 void glFog(FogType name, float param) { gl.glFogf(name, param); }
518 void glFog(FogType name, int param) { gl.glFogi(name, param); }
519 
520 /*NOT DOING
521 alias da_glFogfv = void function( GLenum,const( GLfloat )* );
522 alias da_glFogiv = void function( GLenum,const( GLint )* );
523 alias da_glPolygonStipple = void function( const( GLubyte )* );
524 alias da_glGetPolygonStipple = void function( GLubyte* );*/
525 
526 void glTexGen(TextureCoordinate coord, double v) { gl.glTexGend(coord, gl.GL_TEXTURE_GEN_MODE, v); }
527 void glTexGen(TextureCoordinate coord, float v) { gl.glTexGenf(coord, gl.GL_TEXTURE_GEN_MODE, v); }
528 void glTexGen(TextureCoordinate coord, int v) { gl.glTexGeni(coord, gl.GL_TEXTURE_GEN_MODE, v); }
529 
530 /* NOT DOING
531 alias da_glTexGendv = void function( GLenum,GLenum,const( GLdouble )* );
532 alias da_glTexGenfv = void function( GLenum,GLenum,const( GLfloat )* );
533 alias da_glTexGeniv = void function( GLenum,GLenum,const( GLint )* );*/
534 
535 /*
536 alias da_glGetTexGendv = void function( GLenum,GLenum,GLdouble* );
537 alias da_glGetTexGenfv = void function( GLenum,GLenum,GLfloat* );
538 alias da_glGetTexGeniv = void function( GLenum,GLenum,GLint* );
539 alias da_glTexEnvf = void function( GLenum,GLenum,GLfloat );
540 alias da_glTexEnvi = void function( GLenum,GLenum,GLint );
541 alias da_glTexEnvfv = void function( GLenum,GLenum,const( GLfloat )* );
542 alias da_glTexEnviv = void function( GLenum,GLenum,const( GLint )* );
543 alias da_glGetTexEnvfv = void function( GLenum,GLenum,GLfloat* );
544 alias da_glGetTexEnviv = void function( GLenum,GLenum,GLint* );*/
545 
546 /*
547 alias da_glFeedbackBuffer = void function( GLsizei,GLenum,GLfloat* );
548 alias da_glPassThrough = void function( GLfloat );
549 alias da_glSelectBuffer = void function( GLsizei,GLuint* );
550 alias da_glInitNames = void function();
551 alias da_glLoadName = void function( GLuint );
552 alias da_glPushName = void function( GLuint );
553 alias da_glPopName = void function();
554 alias da_glRenderMode = GLint function( GLenum );*/
555 
556 /*
557 alias da_glClearAccum = void function( GLfloat,GLfloat,GLfloat,GLfloat );
558 alias da_glAccum = void function( GLenum,GLfloat );
559 alias da_glClearIndex = void function( GLfloat c );
560 alias da_glIndexMask = void function( GLuint );
561 alias da_glPushAttrib = void function( GLbitfield );
562 alias da_glPopAttrib = void function();*/
563 
564 /*
565 alias da_glMap1d = void function( GLenum,GLdouble,GLdouble,GLint,GLint,const( GLdouble )* );
566 alias da_glMap1f = void function( GLenum,GLfloat,GLfloat,GLint,GLint,const( GLfloat )* );
567 alias da_glMap2d = void function( GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,GLdouble* );
568 alias da_glMap2f = void function( GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,GLfloat* );
569 alias da_glGetMapdv = void function( GLenum,GLenum,GLdouble* );
570 alias da_glGetMapfv = void function( GLenum,GLenum,GLfloat* );
571 alias da_glGetMapiv = void function( GLenum,GLenum,GLint* );*/
572 
573 /*
574 alias da_glEvalCoord1d = void function( GLdouble );
575 alias da_glEvalCoord1f = void function( GLfloat );
576 alias da_glEvalCoord1dv = void function( const( GLdouble )* );
577 alias da_glEvalCoord1fv = void function( const( GLfloat )* );
578 alias da_glEvalCoord2d = void function( GLdouble,GLdouble );
579 alias da_glEvalCoord2f = void function( GLfloat,GLfloat );
580 alias da_glEvalCoord2dv = void function( const( GLdouble )* );
581 alias da_glEvalCoord2fv = void function( const( GLfloat )* );*/
582 
583 /*
584 alias da_glMapGrid1d = void function( GLint,GLdouble,GLdouble );
585 alias da_glMapGrid1f = void function( GLint,GLfloat,GLfloat );
586 alias da_glMapGrid2d = void function( GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble );
587 alias da_glMapGrid2f = void function( GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat );
588 alias da_glEvalPoint1 = void function( GLint );
589 alias da_glEvalPoint2 = void function( GLint,GLint );
590 alias da_glEvalMesh1 = void function( GLenum,GLint,GLint );
591 alias da_glEvalMesh2 = void function( GLenum,GLint,GLint,GLint,GLint );*/
592 
593 /*
594 alias da_glAlphaFunc = void function( GLenum,GLclampf );
595 alias da_glPixelZoom = void function( GLfloat,GLfloat );
596 alias da_glPixelTransferf = void function( GLenum,GLfloat );
597 alias da_glPixelTransferi = void function( GLenum,GLint );
598 alias da_glPixelMapfv = void function( GLenum,GLint,const( GLfloat )* );
599 alias da_glPixelMapuiv = void function( GLenum,GLint,const( GLuint )* );
600 alias da_glPixelMapusv = void function( GLenum,GLint,const( GLushort )* );
601 alias da_glGetPixelMapfv = void function( GLenum,GLfloat* );
602 alias da_glGetPixelMapuiv = void function( GLenum,GLuint* );
603 alias da_glGetPixelMapusv = void function( GLenum,GLushort* );*/
604 
605 /*
606 alias da_glDrawPixels = void function( GLsizei,GLsizei,GLenum,GLenum,const( void )* );
607 alias da_glCopyPixels = void function( GLint,GLint,GLsizei,GLsizei,GLenum );
608 alias da_glFrustum = void function( GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble );
609 alias da_glMatrixMode = void function( GLenum );
610 alias da_glOrtho = void function( GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble );
611 alias da_glPushMatrix = void function();
612 alias da_glPopMatrix = void function();
613 alias da_glLoadIdentity = void function();*/
614 
615 /*
616 alias da_glLoadMatrixd = void function( const( GLdouble )* );
617 alias da_glLoadMatrixf = void function( const( GLfloat )* );
618 alias da_glMultMatrixd = void function( const( GLdouble )* );
619 alias da_glMultMatrixf = void function( const( GLfloat )* );*/
620 
621 /*
622 alias da_glRotated = void function( GLdouble,GLdouble,GLdouble,GLdouble );
623 alias da_glRotatef = void function( GLfloat,GLfloat,GLfloat,GLfloat );
624 alias da_glScaled = void function( GLdouble,GLdouble,GLdouble );
625 alias da_glScalef = void function( GLfloat,GLfloat,GLfloat );
626 alias da_glTranslated = void function( GLdouble,GLdouble,GLdouble );
627 alias da_glTranslatef = void function( GLfloat,GLfloat,GLfloat );*/
628 
629 /*
630 alias da_glVertexPointer = void function( GLint,GLenum,GLsizei,const( void )* );
631 alias da_glNormalPointer = void function( GLenum,GLsizei,const( void )* );
632 alias da_glColorPointer = void function( GLint,GLenum,GLsizei,const( void )* );
633 alias da_glIndexPointer = void function( GLenum,GLsizei,const( void )* );
634 alias da_glTexCoordPointer = void function( GLint,GLenum,GLsizei,const( void )* );
635 alias da_glEdgeFlagPointer = void function( GLsizei,const( void )* );*/
636 
637 /*
638 alias da_glArrayElement = void function( GLint );
639 alias da_glInterleavedArrays = void function( GLenum,GLsizei,const( void )* );
640 alias da_glEnableClientState = void function( GLenum );
641 alias da_glDisableClientState = void function( GLenum );
642 alias da_glPrioritizeTextures = void function( GLsizei,const( GLuint )*,const( GLclampf )* );
643 alias da_glAreTexturesResident = GLboolean function( GLsizei,const( GLuint )*,GLboolean* );
644 alias da_glPushClientAttrib = void function( GLbitfield );
645 alias da_glPopClientAttrib = void function();*/